package com.qst.controller;

import com.qst.pojo.entity.Item;
import com.qst.repository.ItemRepository;
import com.qst.util.Result;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.web.bind.annotation.*;

import java.util.HashMap;
import java.util.Map;

/**
 * 物品控制器（类的文档注释，说明该类的作用）
 */
// 声明为REST风格的控制器，用于处理HTTP请求并返回JSON等数据
@RestController
// 定义该控制器处理的请求路径前缀为/api/items
@RequestMapping("/api/items")
public class ItemController {

    // 创建日志对象，用于记录日志信息，所属类为ItemController
    private static final Logger logger = LoggerFactory.getLogger(ItemController.class);

    // 自动注入ItemRepository对象，用于数据库操作
    @Autowired
    private ItemRepository itemRepository;

    /**
     * 获取物品列表（分页）
     */
    // 处理HTTP GET请求，对应获取资源的操作
    @GetMapping
    // 方法返回值为Result<Map<String, Object>>，封装了响应结果，方法参数通过@RequestParam获取请求参数，分别为页码、每页条数、关键词、分类、状态
    public Result<Map<String, Object>> getItemList(
            @RequestParam(defaultValue = "1") Integer page,  // 页码，默认值为1
            @RequestParam(defaultValue = "10") Integer pageSize,  // 每页条数，默认值为10
            @RequestParam(required = false) String keyword,  // 关键词，非必需参数
            @RequestParam(required = false) String category,  // 分类，非必需参数
            @RequestParam(required = false) String status  // 状态，非必需参数
    ) {
        try {
            // 创建分页对象，页码从0开始（所以page-1），按id降序排序
            Pageable pageable = PageRequest.of(page - 1, pageSize, Sort.by(Sort.Direction.DESC, "id"));

            // 处理空字符串为null，避免查询时出现问题
            String keywordFilter = (keyword != null && keyword.trim().isEmpty()) ? null : keyword;
            String categoryFilter = (category != null && category.trim().isEmpty()) ? null : category;
            Item.ItemStatus statusFilter = null;  // 声明状态过滤器变量
            if (status != null && !status.trim().isEmpty()) {  // 如果状态参数不为空且不是空字符串
                try {
                    // 将字符串状态转换为Item.ItemStatus枚举类型
                    statusFilter = Item.ItemStatus.valueOf(status);
                } catch (IllegalArgumentException e) {  // 转换失败时捕获异常
                    logger.warn("无效的状态值: {}", status);  // 记录警告日志
                }
            }

            // 根据条件查询物品列表，返回分页结果
            Page<Item> itemPage = itemRepository.findByConditions(keywordFilter, categoryFilter, statusFilter, pageable);

            // 构建返回数据的Map
            Map<String, Object> data = new HashMap<>();
            data.put("list", itemPage.getContent());  // 分页中的物品列表
            data.put("total", itemPage.getTotalElements());  // 总记录数
            data.put("page", page);  // 当前页码
            data.put("pageSize", pageSize);  // 每页条数

            // 返回成功的结果，包含构建的数据
            return Result.success(data);
        } catch (Exception e) {  // 捕获异常
            logger.error("获取物品列表失败", e);  // 记录错误日志
            return Result.error("获取物品列表失败");  // 返回错误结果
        }
    }

    /**
     * 根据ID获取物品详情
     */
    @GetMapping("/{id}")// 处理HTTP GET请求，路径为/api/items/{id}，{id}为路径参数
    // 方法参数通过@PathVariable获取路径中的id
    public Result<Item> getItemById(@PathVariable Integer id) {
        try {
            // 从数据库查询指定id的物品，若存在则返回成功结果，否则返回错误信息
            return itemRepository.findById(id)
                    .map(Result::success)
                    .orElse(Result.error("物品不存在"));
        } catch (Exception e) {  // 捕获异常
            logger.error("获取物品详情失败", e);  // 记录错误日志
            return Result.error("获取物品详情失败");  // 返回错误结果
        }
    }

    /**
     * 创建物品
     */
    // 处理HTTP POST请求，用于创建资源
    @PostMapping
    // 方法参数通过@RequestBody获取请求体中的Item对象
    public Result<Item> createItem(@RequestBody Item item) {
        try {
            // 检查物品名称是否已存在，若存在返回错误信息
            if (itemRepository.existsByName(item.getName())) {
                return Result.error("物品名称已存在");
            }

            // 如果物品状态为null，设置默认状态为active
            if (item.getStatus() == null) {
                item.setStatus(Item.ItemStatus.active);
            }

            // 保存物品到数据库
            Item savedItem = itemRepository.save(item);
            // 返回成功结果，包含创建成功的信息和保存后的物品对象
            return Result.success("物品创建成功", savedItem);
        } catch (Exception e) {  // 捕获异常
            logger.error("创建物品失败", e);  // 记录错误日志
            return Result.error("创建物品失败");  // 返回错误结果
        }
    }

    /**
     * 更新物品信息
     */
    @PutMapping("/{id}")
    // 方法参数为路径中的id和请求体中的Item对象
    public Result<Item> updateItem(@PathVariable Integer id, @RequestBody Item item) {
        try {
            // 查询指定id的物品，若存在则进行更新操作，否则返回错误信息
            return itemRepository.findById(id)
                    .map(existingItem -> {
                        // 检查更新后的名称是否与其他物品重复（排除当前物品）
                        if (!existingItem.getName().equals(item.getName()) &&
                                itemRepository.existsByName(item.getName())) {
                            return Result.<Item>error("物品名称已存在");
                        }

                        // 更新物品的各个字段
                        existingItem.setName(item.getName());
                        existingItem.setCategory(item.getCategory());
                        existingItem.setUnit(item.getUnit());
                        existingItem.setPricePerUnit(item.getPricePerUnit());
                        existingItem.setDescription(item.getDescription());
                        if (item.getStatus() != null) {  // 若状态不为null则更新
                            existingItem.setStatus(item.getStatus());
                        }

                        // 保存更新后的物品
                        Item updatedItem = itemRepository.save(existingItem);
                        // 返回成功结果
                        return Result.success("物品更新成功", updatedItem);
                    })
                    .orElse(Result.error("物品不存在"));
        } catch (Exception e) {  // 捕获异常
            logger.error("更新物品失败", e);  // 记录错误日志
            return Result.error("更新物品失败");  // 返回错误结果
        }
    }

    /**
     * 删除物品（方法文档注释）
     */
    // 处理HTTP DELETE请求，路径为/api/items/{id}，用于删除资源
    @DeleteMapping("/{id}")
    // 方法参数为路径中的id
    public Result<String> deleteItem(@PathVariable Integer id) {
        try {
            // 检查物品是否存在，若不存在返回错误信息
            if (!itemRepository.existsById(id)) {
                return Result.error("物品不存在");
            }

            // 根据id删除物品
            itemRepository.deleteById(id);
            // 返回成功结果
            return Result.success("物品删除成功", "删除成功");
        } catch (Exception e) {  // 捕获异常
            logger.error("删除物品失败", e);  // 记录错误日志
            return Result.error("删除物品失败");  // 返回错误结果
        }
    }

    /**
     * 更新物品状态（方法文档注释）
     */
    // 处理HTTP PATCH请求，路径为/api/items/{id}/status，用于部分更新（仅更新状态）
    @PatchMapping("/{id}/status")
    // 方法参数为路径中的id和请求体中的状态信息（封装在Map中）
    public Result<Item> updateItemStatus(@PathVariable Integer id, @RequestBody Map<String, String> request) {
        try {
            // 从请求体中获取状态字符串
            String statusStr = request.get("status");
            if (statusStr == null) {  // 若状态参数缺失，返回错误信息
                return Result.error("状态参数缺失");
            }

            // 将状态字符串转换为Item.ItemStatus枚举类型
            Item.ItemStatus newStatus;
            try {
                newStatus = Item.ItemStatus.valueOf(statusStr);
            } catch (IllegalArgumentException e) {  // 转换失败，返回错误信息
                return Result.error("无效的状态值");
            }

            // 查询指定id的物品，更新状态并保存
            return itemRepository.findById(id)
                    .map(item -> {
                        item.setStatus(newStatus);
                        Item updatedItem = itemRepository.save(item);
                        return Result.success("状态更新成功", updatedItem);
                    })
                    .orElse(Result.error("物品不存在"));  // 物品不存在时返回错误信息
        } catch (Exception e) {  // 捕获异常
            logger.error("更新物品状态失败", e);  // 记录错误日志
            return Result.error("更新物品状态失败");  // 返回错误结果
        }
    }

    /**
     * 获取物品统计信息（方法文档注释）
     */
    // 处理HTTP GET请求，路径为/api/items/stats，用于获取统计数据
    @GetMapping("/stats")
    // 方法返回统计信息的封装结果
    public Result<Map<String, Object>> getItemStats() {
        try {
            // 统计总物品数
            long totalItems = itemRepository.count();
            // 统计活跃状态的物品数
            long activeItems = itemRepository.findByStatus(Item.ItemStatus.active, Pageable.unpaged()).getTotalElements();
            // 统计非活跃状态的物品数
            long inactiveItems = itemRepository.findByStatus(Item.ItemStatus.inactive, Pageable.unpaged()).getTotalElements();

            // 构建统计信息的Map
            Map<String, Object> stats = new HashMap<>();
            stats.put("totalItems", totalItems);
            stats.put("activeItems", activeItems);
            stats.put("inactiveItems", inactiveItems);

            // 返回成功结果，包含统计信息
            return Result.success(stats);
        } catch (Exception e) {  // 捕获异常
            logger.error("获取物品统计失败", e);  // 记录错误日志
            return Result.error("获取物品统计失败");  // 返回错误结果
        }
    }
}